Data processing apparatus, method, and non-transitory tangible machine-readable medium thereof for recursively structured data

ABSTRACT

Data processing apparatus, method, and non-transitory tangible machine-readable medium thereof for recursively structured data are provided. The data processing apparatus accesses a piece of recursively structured data having a Location Independent Structure and arranges the piece of recursively structured data in a one-dimensional memory space according to LIS:=e 0 ∘e 1 ∘ . . . ∘e p−1 ∘LIS 0 ∘LIS 1 ∘ . . . ∘LIS p−1 . The notation e i  represents an element of the piece of recursively structured data. The notation LIS i  represents a sub-LIS of the recursively structured data and corresponds to the element e i . The operator ‘∘’ indicates “contiguous to” in the one-dimensional memory space. When the elements in all depths are of the element size and the LIS sizes of the sub-LISs within the same depth are the same, the piece of recursively structured data is a complete LIS.

CROSS-REFERENCES TO RELATED APPLICATIONS

Not applicable.

BACKGROUND OF THE INVENTION Field of the Invention

The present invention relates to a data processing apparatus, method, and non-transitory tangible machine-readable medium thereof for recursively structured data. More particularly, the present invention relates to a data processing apparatus, method, and non-transitory tangible machine-readable medium thereof for recursively structured data by using a location independent structure.

Descriptions of the Related Art

With the rapid development in computer technologies, most enterprises collect, store, manipulate, and organize business information/data in computers in a systematic way. Relational databases and on-line analytical processing (OLAP) are examples of commonly adopted technologies.

Although various commercial products of relational databases and OLAP have been developed, they have shortcomings when the amount of business data being stored becomes huge. There are occasions that a business manager would like to make a quick decision based on an analytical result of processing a huge amount of data stored in a database. However, databases on the market today cannot provide a quick response when the amount of data being processed is huge. Accessing and analyzing millions or billions records usually take significant amount of time. For business managers that have to perform analysis and make quick decisions based on big data, the long-processing time of the databases on the market today is intolerable.

To solve the aforementioned problems, Applicants have provided a technique for realizing big data into a big object in U.S. application Ser. No. 13/415,622. Briefly speaking, the technique disclosed therein creates a Big Object from the big data using memory mapped files, lays out a content (comprising a meta information section, a tree section, and a data section) of the Big Object, and lays out a content of the tree section by using a Location Independent Structure (LIS). The technique disclosed in U.S. application Ser. No. 13/415,622 can be further improved, which is provided in this patent application.

SUMMARY OF THE INVENTION

An objective of the present invention is to provide a data processing apparatus. The data processing apparatus comprises a one-dimensional memory space and a processor, wherein the processor is electrically connected to the one-dimensional memory space. The processor is configured to access a piece of recursively structured data, wherein the piece of recursively structured data has a Location Independent Structure (LIS). The processor further arranges the piece of recursively structured data in the one-dimensional memory space in the following way:

LIS:=e ⁰ ∘e ¹ ∘ . . . ∘e ^(p−1)∘LIS⁰∘LIS¹∘ . . . ∘LIS^(p−1).

The variable p is a positive integer, the notation e^(i) represents an element of the piece of recursively structured data, the notation LSI^(i) represents a sub-LIS of the recursively structured data and corresponds to the element e^(i), the variable i is an index of the elements and is between 0 and p−1, the operator ‘ ’ indicates “contiguous to” in the one-dimensional memory space, each of the sub-LISs is of an LIS size, a depth associated to each sub-LIS is a number of recursions from the top LIS, the depth of each LIS^(i) equals the depth of the LIS plus one, and the depth of the top LIS is zero. When the elements in all depths are of the element size and the LIS sizes of the sub-LISs within the same depth are the same, the piece of recursively structured data is a complete LIS.

Another objective of the present invention is to provide a data processing method for use in an electronic apparatus. The data processing method comprises the following steps of: (a) accessing a piece of recursively structured data, wherein the piece of recursively structured data has a Location Independent Structure (LIS) and (b) arranging the piece of recursively structured data in a one-dimensional memory space in the following way:

LIS:=e ⁰ ∘e ¹ ∘ . . . ∘e ^(p−1)∘LIS⁰∘LIS¹∘ . . . ∘LIS^(p−1).

The variable p is a positive integer, the notation e^(i) represents an element of the piece of recursively structured data, the notation LSI^(i) represents a sub-LIS of the recursively structured data and corresponds to the element e^(i), the variable i is an index of the elements and is between 0 and p−1, the operator ‘∘’ indicates “contiguous to” in the one-dimensional memory space, each of the sub-LISs is of an LIS size, a depth associated to each sub-LIS is a number of recursions from the top LIS, the depth of each of the LSI^(i) equals the depth of the LIS plus one, and the depth of the top LIS is zero. When the elements in all depths are of the element size and the LIS sizes of the sub-LISs within the same depth are the same, the piece of recursively structured data is a complete LIS.

A further objective of the present invention is to provide a non-transitory tangible machine-readable medium. The non-transitory tangible machine-readable medium is stored with a computer program, wherein the computer program comprises a plurality of codes. The codes are able to execute a data processing method when the computer program is loaded into an electronic apparatus. The data processing method comprises the following steps of: (a) accessing a piece of recursively structured data, wherein the piece of recursively structured data has a Location Independent Structure (LIS) and (b) arranging the piece of recursively structured data in a one-dimensional memory space in the following way:

LIS:=e ⁰ ∘e ¹ ∘ . . . ∘e ^(p−1)∘LIS⁰∘LIS¹∘ . . . ∘LIS^(p−1).

The variable p is a positive integer, the notation e¹ represents an element of the piece of recursively structured data, the notation LSI^(i) represents a sub-LIS of the recursively structured data and corresponds to the element e^(i), the variable i is an index of the elements and is between 0 and p−1, the operator ‘∘’ indicates “contiguous to” in the one-dimensional memory space, each of the sub-LISs is of an LIS size, a depth associated to each sub-LIS is a number of recursions from the top LIS, the depth of each of the LSI^(i) equals the depth of the LIS plus one, and the depth of the top LIS is zero. When the elements in all depths are of the element size and the LIS sizes of the sub-LISs within the same depth are the same, the piece of recursively structured data is a complete LIS.

The present invention arranges a piece of recursively structured data in a one-dimensional memory space based on a specific way (i.e. LIS:=e⁰∘e¹ ∘ . . . ∘e^(p−1) ∘LIS⁰ ∘LIS¹ ∘ . . . ∘LIS^(p−1)). Therefore, sibling locality (i.e. all sibling elements are placed together in the one-dimensional memory space as one contiguous piece) and descendant locality (i.e. all descendant elements of an element are placed together in the one-dimensional memory space as one contiguous piece) of the piece of recursively structured data 10 are maintained. As a result, retrieval and manipulation can be achieved efficiently, especially when the piece of recursively structured data is complete LIS.

The detailed technology and preferred embodiments implemented for the subject invention are described in the following paragraphs accompanying the appended drawings for people skilled in this field to well appreciate the features of the claimed invention.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A illustrates the data processing apparatus 11 of the first embodiment;

FIG. 1B illustrates an example of the piece of recursively structured data 10;

FIG. 1C illustrates an example showing the denotations of the elements and sub-LISs of the piece of recursively structured data 10;

FIG. 2A illustrates the flowchart for the data processing method of the second embodiment;

FIG. 2B illustrates the steps for aggregation; and

FIG. 2C illustrates the steps for distribution.

DESCRIPTION OF THE PREFERRED EMBODIMENT

In the following descriptions, the data processing apparatus, method, and non-transitory tangible machine-readable medium thereof of the present invention will be explained with reference to embodiments thereof. However, these embodiments are not intended to limit the present invention to any specific environment, applications, or particular implementations described in these embodiments. Therefore, description of these embodiments is only for purpose of illustration rather than to limit the present invention. It should be appreciated that elements unrelated to the present invention are omitted from depiction in the following embodiments and the attached drawings.

In this patent application, a technique for accessing/processing/managing a piece of recursively structured data by a complete Location Independent Structure (LIS) is provided. LIS is a tree data structure without a root node. LIS is a strong-locality approach to arranging memory for a data set of elements in a hierarchical (tree) way. With strong locality, relevant data elements are grouped tightly together (without any irrelevant data elements in between) for management and performance purposes. In management, an LIS or its sub-LIS (i.e. sub-component or sub-tree) can be relocated to other memory space as one piece without handling any pointers. This is the reason why LIS is named in the first place. In performance, a big LIS can be accessed and operated efficiently based on the locality principle. LIS is intentionally designed for big data computing.

A first embodiment of the present invention is a data processing apparatus 11, which is illustrated in FIG. 1A. The data processing apparatus 11 comprises a one-dimensional memory space 111, a processor 113, a network interface 115, and an input interface 117, wherein the processor 113 is electrically connected to the one-dimensional memory space 111, the network interface 115, and the input interface 117. The one-dimensional memory space 111 may be a Static Random Access Memory (SRAM), a Dynamic Random Access Memory (DRAM), a Flash or other memory space well known to those of ordinary skill in the art. The processor 113 may be any of various processors, central processing units (CPUs), microprocessors, or other computing devices well known to those of ordinary skill in the art. The network interface 115 may be a network interface card or other interface that can connect the data processing apparatus 11 to a storage device. The input interface 117 may be a keyboard, a mouse, or other interface that can receive instructions inputted by a user.

In this embodiment, the network interface 115 is electrically connected to a storage device 13 having a piece of recursively structured data 18 stored therein. In some other embodiments, the data processing apparatus 11 may further comprise a storage device having the piece of recursively structured data 18 stored therein. For those embodiments, the network interface 115 may be omitted from the data processing apparatus 11. That is to say, the present invention does not limit the location that the piece of recursively structured data 18 is stored.

In this embodiment, the processor 113 accesses the piece of recursively structured data 18 in the storage device 13 through the network interface 115. The piece of recursively structured data 18 has a Location Independent Structure (LIS). The processor 113 further arranges the piece of recursively structured data 18 in the one-dimensional memory space 111 as the piece of recursively structured data 10 according to the following Equation (1).

LIS:=e ⁰ ∘e ¹ ∘ . . . ∘e ^(p−1)∘LIS⁰∘LIS¹∘ . . . ∘LIS^(p−1).

In Equation (1), the variable p is a positive integer, the notation e^(i) represents an element of the piece of recursively structured data 10, the notation LSI^(i) represents a sub-LIS of the recursively structured data 10 and corresponds to the element e^(i), the variable i is an index of the elements and is between 0 and p−1, and the operator ‘∘’ indicates “contiguous to” in the one-dimensional memory space 111. By arranging the piece of recursively structured data 10 according to Equation (1), the piece of recursively structured data 10 in the one-dimensional memory space 111 starts with the element e⁰ adjacent to the element e¹, the element e¹ adjacent to the element e², until adjacent to the element e^(p−1), which is adjacent to the sub-LIS LIS⁰, then adjacent to the sub-LIS LIS¹, until adjacent to the sub-LIS LIS^(p−1). The elements e⁰, e¹, . . . , e^(p−1) are sibling elements and the sub-LISs LIS⁰, LIS¹, . . . , LIS^(p−1) are sibling sub-LISs. In this specification, a superscript is used to denote an index of a sibling.

A depth (or level) associated to each of the sub-LISs is a number of recursions from the top LIS. The depth of each sub-LIS (i.e. LSI^(i)) equals the depth of the LIS plus one, while the depth of the top LIS is zero. Each of the sub-LISs is of an LIS size. When the elements in all depths are of the element size (i.e. the element sizes of all the elements are the same) and the LIS sizes of the sub-LISs within the same depth are the same, the piece of recursively structured data 10 is a complete LIS.

Please refer to FIG. 1B, which illustrates an example of the LIS for the piece of recursively structured data 10 with maximum depth being 4. A subscript is used to denote a depth in this specification. The piece of recursively structured data 10 is named “X” in this example. In FIG. 1B, the notation LIS₀ represents X (i.e. the LIS of depth 0) and the notation LIS_(m) indicates a sub-LIS of X with depth m. The relations between X, LIS₀, and LIS_(m) can be represented in the following way:

LIS₀ =X

LIS₀→LIS₁→ . . . →LIS_(m)

In FIG. 1B, the element e_(m) indicates one of the elements with depth m or an element of LIS_(m). The relation between e_(m) and LIS_(m) can be represented as “LIS_(m)→e_(m)” wherein the element e_(m) is selected from the elements of LIS_(m). Moreover, the element e_(m) may be located via a path “LIS₀→e₀→LIS₁→e₁→ . . . →e_(m−1)→LIS_(m)→e_(m)” It is noted that LIS_(m) is the sub-LIS corresponding to the element e_(m−1).

With the above arrangement, the piece of recursively structured data 10 in the one-dimensional memory space 111 maintains sibling locality and descendant locality. To be more specific, sibling locality means that all sibling elements are placed together in the one-dimensional memory space 111 as one contiguous piece. In addition, descendant locality means that all descendant elements of an element are placed together in the one-dimensional memory space 111 as one contiguous piece.

In some embodiments, the piece of recursively structured data 10 is a complete LIS (i.e. when the elements in all depths are of the element size and the LIS sizes of the sub-LISs within the same depth are the same). The maximum depth of the piece of recursively structured data 10 may be denoted by a variable n, wherein the variable n is a nonnegative integer. The piece of recursively structured data 10 may be denoted as an array in the following Expression (2):

LIS T X [D ₀ ,D ₁ ,D ₂ , . . . ,D _(n)]  (2)

In Expression (2), the notation X is the name of the piece of recursively structured data 10, the array is of n+1 dimensions (i.e. from the zeroth dimension to the n^(th) dimension), each of the dimensions corresponds to a dimension size, the notation T represents a data type of the elements, the variable D_(j) represents the dimension size of the j-th dimension, the j-th dimension corresponds to the j-th depth of the piece of recursively structured data 10, and the variable j is an index of the dimension between 0 and n.

When the piece of recursively structured data 10 is denoted as the above array, each of the elements may be denoted as X[I₀, . . . , I_(m)] (Expression (3) for short). The variable m is an integer between 0 and n and represents an index corresponding to the m-th dimension, wherein the variable I_(m) is between 0 and D_(m)−1. The notation X[I₀] is the I₀-th element of the LIS, the notation X[I₀, . . . , I_(m−1), I_(m)] is the I_(m)-th element of LIS_(m) ^(I) ^(m−1) , and the notation LIS_(m) ^(I) ^(m−1) represents the I_(m−1)-th sub-LIS of the depth m.

Please refer to FIG. 1C, which illustrates an example showing the denotations of the elements and sub-LISs of the piece of recursively structured data 10. In this example, the piece of recursively structured data 10 is with maximum depth being 4 and the piece of recursively structured data 10 is named “X.” In FIG. 1C, the elements corresponding to X[I₀], X[I₀, I₁], X[I₀, I₁, I₂], X[I₀, I₁, I₂, I₃], and X[I₀, I₁, I₂, I₃, I₄] are labeled and the sub-LISs corresponding to LIS₀, LIS₁ ^(I) ⁰ , LIS₂ ^(I) ¹ , LIS₃ ^(I) ² , and LIS₄ ^(I) ³ are labeled. In some embodiments, the element X[I₀, . . . , I_(m−1), I_(m)] may be further located by the path LIS→X[I₀]→LIS₁ ^(I) ⁰ →X[I₀, I₁]→LIS₂ ^(I) ¹ → . . . →X[I₀, . . . , I_(m−1)]→LIS₁ ^(I) ^(m−1) →X[I₀, . . . , I_(m)] (Path (4) for short). The notation LIS_(j) ^(I) ^(j−1) represents the sub-LIS corresponding to the element X[I₀, . . . , I_(j−1)], wherein 0<1≦m.

A concrete example is given herein for better understanding. When the piece of recursively structured data 10 is related to sales, the piece of recursively structured data 10 may be denoted by the following array:

-   -   LIS Integer Sales[12, 31, 24, 60, 60].

In this example, the name of the piece of recursively structured data 10 is “Sales.” The array of the piece of recursively structured data 10 has 5 dimensions, from the zeroth dimension to the fourth dimension. The data type of the elements of the piece of recursively structured data 10 is integer. The zeroth, first, second, third, and fourth dimensions respectively correspond to month, day, hour, minute, and second. The dimension sizes D₀, D₁, D₂, D₃, and D₄ for the zeroth, first, second, third, and fourth dimensions are respectively 12, 31, 24, 60, and 60. In this way, the LIS Sales can be used to hold the sales values indexed by time—month, day, hour, minute, and second.

For example, Sales[8] (i.e. Sales[I₀] with I₀ being 8 is the 8^(th) element of the LIS Sales) holds an aggregated sales value for September. As another example, Sales[8, 3] (i.e. Sales[I₀, I₁] with I₀ and I₁ respectively being 8 and 3 is the third element of LIS₁ ⁸ (i.e. LIS_(m) ^(I) ^(m−1) =LIS_(m) ^(I) ⁰ =LIS₁ ⁸)) holds an aggregated sales value for September 4^(th). As another example, Sales[8, 3, 8] (i.e. Sales[I₀, I₁, I₂] with I₀, I₁, and I₂ respectively being 8, 3, and 8 is the 8^(th) element of LIS₂ ³ (i.e. LIS_(m) ^(I) ^(m−1) =LIS₂ ^(I) ¹ =LIS₂ ³)) holds an aggregated sales value for September 4^(th) 8 am. As another example, Sales[8, 3, 8, 30] (i.e. Sales[I₀, I₁, I₂, I₃] with I₀, I₁, I₂, and I₃ respectively being 8, 3, 8, and 30 is the 30th element of LIS (i.e. LIS_(m) ^(I) ^(m−1) =LIS₃ ^(I) ² =LIS₃ ⁸)) holds an aggregated sales value for September 4^(th), 8:30. As another example, Sales[8, 3, 8, 30, 10] (i.e. Sales[I₀, I₁, I₂, I₃, I₄] with I₀, I₁, I₂, I₃, and I₄ respectively being 8, 3, 8, 30, and 10 is the 10th element of usr (i.e. LIS_(m) ^(I) ^(m−1) =LIS₄ ^(I) ³ =LIS₄ ³⁰)) holds a sales value for September 4^(th), 8:30:10.

After the piece of recursively structured data 10 has been arranged in the one-dimensional memory space 111 according to the above Equation (1), the piece of recursively structured data 10 may be retrieved and/or manipulated. As mentioned, the piece of recursively structured data 10 in the one-dimensional memory space 111 maintains sibling locality and descendant locality, so retrieval and manipulation can be achieved efficiently.

In some embodiments, the input interface 117 further receives an instruction 12 for retrieving an element or a sub-LIS of the piece of recursively structured data 10. The instruction 12 comprises an index combination represented as (I₀, . . . , I_(m)). Then, the processor 113 retrieves the element corresponding to the index combination or the sub-LIS corresponding to the index combination from the one-dimensional memory space 111 according to the following Equations (5), (6), and (7):

$\begin{matrix} {\mspace{79mu} \left\{ \begin{matrix} {S_{m} = {D_{m} \times \left( {t + S_{m + 1}} \right)}} & {{{for}\mspace{14mu} 0} \leq m \leq n} \\ {S_{m} = 0} & {{{for}\mspace{14mu} m} > n} \end{matrix} \right.} & (5) \\ \left\{ \begin{matrix} {{X\left( I_{0} \right\rbrack} = {{{LIS}(X)} + {I_{0} \times t}}} & \; \\ {{X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} = {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m - 1}} \right\rbrack} \right)} + {I_{m} \times t}}} & {{{for}\mspace{14mu} 0} < m \leq n} \end{matrix} \right. & (6) \\ \left\{ \begin{matrix} {{{LIS}\left( {X\left\lbrack I_{0} \right\rbrack} \right)} = {{{LIS}(X)} + {D_{0} \times t} + {I_{0} \times S_{1}}}} & \; \\ \begin{matrix} {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} \right)} = {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m - 1}} \right\rbrack} \right)} +}} \\ {{D_{m} \times t} + {I_{m} \times S_{m + 1}}} \end{matrix} & {{{for}\mspace{14mu} 0} < m < n} \end{matrix} \right. & (7) \end{matrix}$

In the above Equations (5), (6), and (7), the notation S₁ represents the LIS size of the first dimension, the notation S_(m) represents the LIS size of the m^(th) dimension, the notation S_(m+1) represents the LIS size of the m+1^(th) dimension, the variable t represents the element size, the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . I_(m)), the notation LIS(X) represents an offset of the LIS X, the notation LIS(X[I₀]) represents an offset of the sub-LIS corresponding to the element X[I₀], the notation LIS(X[I₀, . . . , I_(m−1), I_(m)]) represents an offset of the sub-LIS corresponding to the element X[I₀, . . . , I_(m−1), I_(m)], and the notation LIS(X[I₀, . . . , I_(m)]) represents an offset of the sub-LIS for the index combination (I₀, . . . I_(m)) and corresponds to the element X[I₀, . . . , I_(m)].

In some embodiments, LIS is designed to maintain a tree of data. Elements (i.e. intermediate nodes) can be used to store aggregated values such as sum, count, max, min, means, standard deviation, or any function based on data in the child nodes. The input interface 117 further receives an instruction 14 for aggregation. The instruction 14 comprises an index combination represented as (I₀, . . . , I_(m)), the variable m is a non-negative integer between zero and n, the notation I_(k) represents an index corresponding to the k^(th) dimension, and the variable k is an index between 0 and m, The processor 113 then calculates a value for the element corresponding to the index combination by an aggregation function according to the following Equation (8):

$\begin{matrix} {{X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} = {{f\left( {{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} \right)} \right)} = {{{f\left( {{X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m},0} \right\rbrack},{X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m},1} \right\rbrack},\ldots \mspace{11mu},{X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m},{D_{m + 1} - 1}} \right\rbrack}} \right)}\mspace{14mu} {for}\mspace{14mu} 0} \leq m < n}}} & (8) \end{matrix}$

In the above Equation (8), the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation f( ) represents the aggregation function, the notation LIS(X[I₀, . . . , I_(m)]) represents the sub-LIS for the index combination (I₀, . . . , I_(m)), the notation X[I₀, . . . , I_(m), 0] represents the element for an index combination (I₀, . . . , I_(m), 0), the notation X[I₀, . . . , I_(m), 1] represents the element for an index combination (I₀, . . . , I_(m), 1), the notation X[I₀, . . . , I_(m), D_(m+1)−1] represents the element for an index combination (I₀, . . . , I_(m), D_(m+1)−1), and the notation D_(m+1) represents the dimension size of the m+1^(th) dimension.

In some embodiments, the input interface 117 further receives an instruction 16 for distribution. The instruction 16 comprises an index combination represented as (I₀, . . . , I_(m)), the variable m is a non-negative integer between zero and n, the notation I_(k) represents an index corresponding to the k^(th) dimension, and the variable k is an index between 0 and m. The processor 113 further calculates a value for the element corresponding to the index combination by a distribution function according to the following Equation (9):

(X[I ₀ , . . . ,I _(m),0],X[I ₀ , . . . ,I _(m),1], . . . ,X[I ₀ , . . . ,I _(m) ,D _(m+1)−1])=g(X[I ₀ , . . . ,I _(m)]) for 0≦m<n  (9)

In Equation (9), the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation g( ) represents the distribution function, the notation X[I₀, . . . , I_(m), 0] represents the element for an index combination (I₀, . . . , I_(m), 0), the notation X[I₀, . . . , I_(m), 1] represents the element for an index combination (I₀, . . . , I_(m), 1), the notation X[I₀, . . . , I_(m), D_(m+1)−1] represents the element for an index combination (I₀, . . . , I_(m), D_(m+1)−1), and the notation D_(m+1) represents the dimension size of the m+1^(th) dimension.

According to the above descriptions, the data processing apparatus 11 arranges the piece of recursively structured data 10 in the one-dimensional memory space 111 based on Equation (1). In this way, sibling locality and descendant locality of the piece of recursively structured data 10 are maintained. When the piece of recursively structured data 10 is complete LIS, retrieval and manipulation can be achieved efficiently.

A second embodiment of the present invention is a data processing method for use in an electronic apparatus (e.g. the data processing apparatus 11 of the first embodiment). The flowchart of the second embodiment is illustrated in FIG. 2A. The data processing method is able to arrange a piece of recursively structured data in a one-dimensional memory space in a way that sibling locality and descendant locality are maintained.

To achieve that, step S201 is executed by the electronic apparatus for accessing a piece of recursively structured data. The piece of recursively structured data has a Location Independent Structure (LIS). The piece of recursively structured data may be stored within the electronic apparatus or external to the electronic apparatus. Next, step S203 is executed by the electronic apparatus for arranging the piece of recursively structured data in a one-dimensional memory space according to the above Equation (1). For the details of Equation (1), please refer to the descriptions in the first embodiment.

When the piece of recursively structured data is a complete LIS (i.e. when the elements in all depths are of the element size and the LIS sizes of the sub-LISs within the same depth are the same), the piece of recursively structured data may be denoted as an array by the above Expression (2) and each of the elements may be denoted by the above Expression (3). In addition, an element X[I₀, . . . , I_(m−1), I_(m)] may be located by the above Path (4).

In some embodiments, step S205 is executed by the electronic apparatus for receiving an instruction for retrieving an element or a sub-LIS of the piece of recursively structured data. The instruction comprises an index combination represented as (I₀, . . . , I_(m)). Then, step S207 is executed by the electronic apparatus for retrieving the element corresponding to the index combination or the sub-LIS corresponding to the index combination from the one-dimensional memory space according to the above Equations (5), (6), and (7).

In some embodiments, LIS is designed to maintain a tree of data. Elements (i.e. intermediate nodes) can be used to store aggregated values such as sum, count, max, min, means, standard deviation, or any function based on data in the child nodes. For those embodiments, the data processing method may further execute the steps illustrated in FIG. 2B for aggregation. In step S209, the electronic apparatus receives an instruction for aggregation. The instruction comprises an index combination represented as (I₀, . . . , I_(m)). In step S211, the electronic apparatus calculates a value for the element corresponding to the index combination by an aggregation function, which is the above Equation (8).

In some embodiments, the data processing method may further execute the steps illustrated in FIG. 2C for distribution. In step S213, the electronic apparatus receives an instruction for distribution. The instruction comprises an index combination represented as (I₀, . . . , I_(m)). Next, in step S215, the electronic apparatus for calculates a value for the element corresponding to the index combination by a distribution function shown in Equation (9).

In addition to the aforesaid steps, the second embodiment can also execute all the operations and functions set forth in the first embodiment. How the second embodiment executes these operations and functions will be readily appreciated by those of ordinary skill in the art based on the explanation of the first embodiment, and thus will not be further described herein.

The data processing method described in the second embodiment may be implemented as a computer program. When the computer program is loaded into an electronic apparatus, a plurality of codes comprised in the computer program are able to perform method for querying a database of the second and third embodiments. This computer program may be stored in a non-transitory tangible machine-readable medium, such as a read only memory (ROM), a flash memory, a floppy disk, a hard disk, a compact disk (CD), a mobile disk, a magnetic tape, a database accessible to networks, or any other storage media with the same function and well known to those skilled in the art.

The present invention arranges a piece of recursively structured data in a one-dimensional memory space based on a specific way (i.e. LIS:=e⁰∘e¹ ∘ . . . ∘e^(p−1) ∘LIS⁰ ∘LIS¹ ∘ . . . ∘LIS^(p−1). Therefore, sibling locality (i.e. all sibling elements are placed together in the one-dimensional memory space as one contiguous piece) and descendant locality (i.e. all descendant elements of an element are placed together in the one-dimensional memory space as one contiguous piece) of the piece of recursively structured data 10 are maintained. As a result, retrieval and manipulation can be achieved efficiently, especially when the piece of recursively structured data is complete LIS.

The above disclosure is related to the detailed technical contents and inventive features thereof. People skilled in this field may proceed with a variety of modifications and replacements based on the disclosures and suggestions of the invention as described without departing from the characteristics thereof. Nevertheless, although such modifications and replacements are not fully disclosed in the above descriptions, they have substantially been covered in the following claims as appended. 

What is claimed is:
 1. A data processing apparatus, comprising: a one-dimensional memory space; and a processor, being electrically connected to the one-dimensional memory space and configured to access a piece of recursively structured data, wherein the piece of recursively structured data has a Location Independent Structure (LIS), wherein the processor further arranges the piece of recursively structured data in the one-dimensional memory space in the following way: LIS:=e ⁰ ∘e ¹ ∘ . . . ∘e ^(p−1)∘LIS⁰∘LIS¹∘ . . . ∘LIS^(p−1), wherein the variable p is a positive integer, the notation e^(i) represents an element of the piece of recursively structured data, the notation LIS^(i) represents a sub-LIS of the recursively structured data and corresponds to the element e^(i), the variable i is an index of the elements and is between 0 and p−1, the operator ‘∘’ indicates “contiguous to” in the one-dimensional memory space, each of the sub-LISs is of an LIS size, a depth associated to each sub-LIS is a number of recursions from the top LIS, the depth of each LIS^(i) equals the depth of the LIS plus one, and the depth of the top LIS is zero, wherein when the elements in all depths are of the element size and the LIS sizes of the sub-LISs within the same depth are the same, the piece of recursively structured data is a complete LIS.
 2. The data processing apparatus of claim 1, wherein when the piece of recursively structured data is the complete LIS, the piece of recursively structured data whose maximum depth is n is denoted as an array in the following way: LIS T X [D ₀ ,D ₁ ,D ₂ , . . . ,D _(n)], wherein X is the name of the piece of recursively structured data, the variable n is a nonnegative integer, the array is of n+1 dimensions, each of the dimensions corresponds to a dimension size, the notation T represents a data type of the elements, the variable D_(j) represents the dimension size of the j-th dimension, the j-th dimension corresponds to the j-th depth of the piece of recursively structured data, and the variable j is an index of the dimension between 0 and n, wherein each of the elements is denoted as X[I₀, . . . , I_(m)], the variable m is an integer between 0 and n, the variable I_(m) represents an index corresponding to the m-th dimension, I_(m) is between 0 and D_(m)−1, the notation X[I₀] is the I₀-th element of the LIS, the notation X[I₀, . . . , I_(m−1), I_(m)] is the I_(m)-th element of LIS_(m) ^(I) ^(m−1) , and the notation LIS_(m) ^(I) ^(m−1) represents the I_(m−1)-th sub-LIS of the depth m.
 3. The data processing apparatus of claim 2, wherein the element X[I₀, . . . , I_(m−1), I_(m)] is located by the following path: LIS→X[I ₀]→LIS₁ ^(I) ⁰ →X[I ₀ ,I ₁]→LIS₂ ^(I) ¹ → . . . →X[I ₀ , . . . ,I _(m−1)]→LIS₁ ^(I) ^(m−1) →X[I ₀ , . . . ,I _(m)], wherein the notation LIS₁ ^(I) ^(j−1) represents the sub-LIS corresponding to the element X[I₀, . . . , I_(j−1)] and 0<j≦m.
 4. The data processing apparatus of claim 2, further comprising: an input interface, being electrically connected to the processor and configured to receive an instruction comprising an index combination, wherein the index combination is represented as (I₀, . . . , I_(m)), wherein the processor further retrieves the element corresponding to the index combination and the sub-LIS corresponding to the index combination from the one-dimensional memory space according to the following equations: $\mspace{50mu} \left\{ {\begin{matrix} {S_{m} = {D_{m} \times \left( {t + S_{m + 1}} \right)}} & {{{for}\mspace{14mu} 0} \leq m \leq n} \\ {S_{m} = 0} & {{{for}\mspace{14mu} m} > n} \end{matrix},\left\{ {\begin{matrix} {{X\left( I_{0} \right\rbrack} = {{{LIS}(X)} + {I_{0} \times t}}} & \; \\ {{X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} = {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m - 1}} \right\rbrack} \right)} + {I_{m} \times t}}} & {{{for}\mspace{14mu} 0} < m \leq n} \end{matrix},{{and}\left\{ {\begin{matrix} {{{LIS}\left( {X\left\lbrack I_{0} \right\rbrack} \right)} = {{{LIS}(X)} + {D_{0} \times t} + {I_{0} \times S_{1}}}} & \; \\ \begin{matrix} {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} \right)} = {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m - 1}} \right\rbrack} \right)} +}} \\ {{D_{m} \times t} + {I_{m} \times S_{m + 1}}} \end{matrix} & {{{for}\mspace{14mu} 0} < m < n} \end{matrix},} \right.}} \right.} \right.$ wherein the notation S₁ represents the LIS size of the first dimension, the notation S_(m) represents the LIS size of the m^(th) dimension, the notation S_(m+1) represents the LIS size of the m+1^(th) dimension, the variable t represents the element size, the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation LIS(X) represents an offset of the LIS X, the notation LIS(X[I₀]) represents an offset of the sub-LIS corresponding to the element X[I₀], the notation LIS(X[I₀, . . . , I_(m−1), I_(m)]) represents an offset of the sub-LIS corresponding to the element [I₀, . . . , I_(m−1), I_(m)], and the notation LIS(X[I₀, . . . , I_(m)]) represents an offset of the sub-LIS for the index combination (I₀, . . . , I_(m)) and corresponds to the element X[I₀, . . . , I_(m)].
 5. The data processing apparatus of claim 2, further comprising: an input interface, being electrically connected to the processor and configured to receive an instruction comprising an index combination, wherein the index combination is represented as (I₀, . . . , I_(m)), the variable m is a non-negative integer between zero and n, the notation I_(k) represents an index corresponding to the k^(th) dimension, and the variable k is an index between 0 and m, wherein the processor calculates a value for the element corresponding to the index combination by an aggregation function according to the following equation: X[I₀, …  , I_(m)] = f(LIS(X[I₀, …  , I_(m)])) = f(X[I₀, …  , I_(m), 0], X[I₀, …  , I_(m), 1], …  , X[I₀, …  , I_(m), D_(m + 1) − 1])  for  0 ≤ m < n, wherein the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation f( ) represents the aggregation function, the notation LIS(X[I₀, . . . , I_(m)]) represents the sub-LIS for the index combination (I₀, . . . , I_(m)), the notation X[I₀, . . . , I_(m), 0] represents the element for an index combination (I₀, . . . , I_(m), 0), the notation X[I₀, . . . , I_(m), 1] represents the element for an index combination (I₀, . . . , I_(m), 1), the notation X[I₀, . . . , I_(m), D_(m+1)−1] represents the element for an index combination (I₀, . . . , I_(m), D_(m+1)−1), and the notation D_(m+1) represents the dimension size of the m+1^(th) dimension.
 6. The data processing apparatus of claim 2, further comprising: an input interface, being electrically connected to the processor and configured to receive an instruction comprising an index combination, wherein the index combination is represented as (I₀, . . . , I_(m)), the variable m is a non-negative integer between zero and n, the notation I_(k) represents an index corresponding to the k^(th) dimension, and the variable k is an index between 0 and m, wherein the processor calculates a value for the element corresponding to the index combination by a distribution function according to the following equation: (X[I ₀ , . . . ,I _(m),0],X[I ₀ , . . . ,I _(m),1], . . . ,X[I ₀ , . . . ,I _(m) ,D _(m+1)−1])=g(X[I ₀ , . . . ,I _(m)]) for 0≦m<n′ wherein the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation g( ) represents the distribution function, the notation [I₀, . . . , I_(m), 0] represents the element for an index combination (I₀, . . . , I_(m), 0), the notation X[I₀, . . . , I_(m), 1] represents the element for an index combination (I₀, . . . , I_(m), 1), the notation X[I₀, . . . , I_(m), D_(m+1)−1] represents the element for an index combination (I₀, . . . , I_(m), D_(m+1)−1), and the notation D_(m+1) represents the dimension size of the m+1^(th) dimension.
 7. A data processing method for use in an electronic apparatus, comprising the following steps of: accessing a piece of recursively structured data, wherein the piece of recursively structured data has a Location Independent Structure (LIS); and arranging the piece of recursively structured data in a one-dimensional memory space in the following way: LIS:=e ⁰ ∘e ¹ ∘ . . . ∘e ^(p−1)∘LIS⁰∘LIS¹∘ . . . ∘LIS^(p−1). wherein the variable p is a positive integer, the notation e^(i) represents an element of the piece of recursively structured data, the notation LIS represents a sub-LIS of the recursively structured data and corresponds to the element e^(i), the variable i is an index of the elements and is between 0 and p−1, the operator ‘∘’ indicates “contiguous to” in the one-dimensional memory space, each of the sub-LISs is of an LIS size, a depth associated to each sub-LIS is a number of recursions from the top LIS, the depth of each of the LIS^(i) equals the depth of the LIS plus one, and the depth of the top LIS is zero, wherein when the elements in all depths are of the element size and the LIS sizes of the sub-LISs within the same depth are the same, the piece of recursively structured data is a complete LIS.
 8. The data processing method of claim 7, wherein when the piece of recursively structured data is the complete LIS, the piece of recursively structured data whose maximum depth is n is denoted as an array in the following way: LIS T X[D ₀ ,D ₁ ,D ₂ , . . . ,D _(n)], wherein X is the name of the piece of recursively structured data, the variable n is a nonnegative integer, the array is of n+1 dimensions, each of the dimensions corresponds to a dimension size, the notation T represents a data type of the elements, the variable D_(j) represents the dimension size of the j-th dimension, the j-th dimension corresponds to the j-th depth of the piece of recursively structured data, and the variable j is an index of the dimension between 0 and n, wherein each of the elements is denoted as X[I₀, . . . , I_(m)], the variable m is an integer between 0 and n, the variable I_(m) represents an index corresponding to the m-th dimension, I_(m) is between 0 and D_(m)−1, the notation X[I₀] is the I₀-th element of the LIS, the notation X[I₀, . . . , I_(m−1), I_(m)] is the I_(m)-th element of LIS_(m) ^(I) ^(m−1) , and the notation LIS_(m) ^(I) ^(m−1) represents the I_(m−1)-th sub-LIS of the depth m.
 9. The data processing method of claim 8, wherein the element X[I₀, . . . , I_(m−1), I_(m)] is located by the following path: LIS→X[I ₀]→LIS₁ ^(I) ⁰ →X[I ₀ ,I ₁]→LIS₂ ^(I) ¹ → . . . →X[I ₀ , . . . ,I _(m−1)]→LIS₁ ^(I) ^(m−1) →X[I ₀ , . . . ,I _(m)], wherein the notation LIS_(m) ^(I) ^(j−1) represents the sub-LIS corresponding to the element X[I₀, . . . , I_(j−1)], and 0<j≦m.
 10. The data processing method of claim 8, further comprising the following steps of: receiving an instruction comprising an index combination, wherein the index combination is represented as (I₀, . . . , I_(m)); and retrieving the element corresponding to the index combination and the sub-LIS corresponding to the index combination from the one-dimensional memory space according to the following equations: $\mspace{70mu} \left\{ {\begin{matrix} {S_{m} = {D_{m} \times \left( {t + S_{m + 1}} \right)}} & {{{for}\mspace{14mu} 0} \leq m \leq n} \\ {S_{m} = 0} & {{{for}\mspace{14mu} m} > n} \end{matrix},\left\{ {\begin{matrix} {{X\left( I_{0} \right\rbrack} = {{{LIS}(X)} + {I_{0} \times t}}} & \; \\ {{X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} = {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m - 1}} \right\rbrack} \right)} + {I_{m} \times t}}} & {{{for}\mspace{14mu} 0} < m \leq n} \end{matrix},{{and}\left\{ {\begin{matrix} {{{LIS}\left( {X\left\lbrack I_{0} \right\rbrack} \right)} = {{{LIS}(X)} + {D_{0} \times t} + {I_{0} \times S_{1}}}} & \; \\ \begin{matrix} {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} \right)} = {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m - 1}} \right\rbrack} \right)} +}} \\ {{D_{m} \times t} + {I_{m} \times S_{m + 1}}} \end{matrix} & {{{for}\mspace{14mu} 0} < m < n} \end{matrix},} \right.}} \right.} \right.$ wherein the notation S₁ represents the LIS size of the first dimension, the notation S_(m) represents the LIS size of the m^(th) dimension, the notation S_(m+1) represents the LIS size of the m+1^(th) dimension, the variable t represents the element size, the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation LIS(X) represents an offset of the LIS X, the notation LIS(X[I₀]) represents an offset of the sub-LIS corresponding to the element X[I₀], the notation LIS(X[I₀, . . . , I_(m−1), I_(m)]) represents an offset of the sub-LIS corresponding to the element X[I₀, . . . , I_(m−1), I_(m)], and the notation LIS(X[I₀, . . . , I_(m)]) represents an offset of the sub-LIS for the index combination (I₀, . . . , I_(m)) and corresponds to the element X[I₀, . . . , I_(m)].
 11. The data processing method of claim 8, further comprising the following step of: receiving an instruction comprising an index combination, wherein the index combination is represented as (I₀, . . . , I_(m)), the variable m is a non-negative integer between zero and n, the notation I_(k) represents an index corresponding to the k^(th) dimension, and the variable k is an index between 0 and m; and calculating a value for the element corresponding to the index combination by an aggregation function according to the following equation:   X[I₀, …  , I_(m)] = f(LIS(X[I₀, …  , I_(m)])) = f(X[I₀, …  , I_(m), 0], X[I₀, …  , I_(m), 1], …  , X[I₀, …  , I_(m), D_(m + 1) − 1])  for  0 ≤ m < n, wherein the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation f( ) represents the aggregation function, the notation LIS(X[I₀, . . . , I_(m)]) represents the sub-LIS for the index combination (I₀, . . . , I_(m)), the notation X[I₀, . . . , I_(m), 0] represents the element for an index combination (I₀, . . . , I_(m), 0), the notation X[I₀, . . . , I_(m), 1] represents the element for an index combination (I₀, . . . , I_(m), 1), the notation X[I₀, . . . , I_(m), D_(m+1)−1] represents the element for an index combination (I₀, . . . , I_(m), D_(m+1)−1), and the notation D_(m+1) represents the dimension size of the m+1^(th) dimension.
 12. The data processing method of claim 8, further comprising the following step of: receiving an instruction comprising an index combination, wherein the index combination is represented as (I₀, . . . , I_(m)), the variable m is a non-negative integer between zero and n, the notation I_(k) represents an index corresponding to the k^(th) dimension, and the variable k is an index between 0 and m; and calculates a value for the element corresponding to the index combination by a distribution function according to the following equation: (X[I ₀ , . . . ,I _(m),0],X[I ₀ , . . . ,I _(m),1], . . . ,X[I ₀ , . . . ,I _(m) ,D _(m+1)−1])=g(X[I ₀ , . . . ,I _(m)]) for 0≦m<n′ wherein the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation g( ) represents the distribution function, the notation X[I₀, . . . , I_(m), 0] represents the element for an index combination (I₀, . . . , I_(m), 0), the notation X[I₀, . . . , I_(m), 1] represents the element for an index combination (I₀, . . . , I_(m), 1), the notation X[I₀, . . . , I_(m), D_(m+1)−1] represents the element for an index combination (I₀, . . . , I_(m), D_(m+1)−1), and the notation D_(m+1) represents the dimension size of the m+1^(th) dimension.
 13. A non-transitory tangible machine-readable medium, being stored with a computer program, the computer program comprising a plurality of codes, the codes being able to execute a data processing method when the computer program is loaded into an electronic apparatus, the data processing method comprising the steps of: accessing a piece of recursively structured data, wherein the piece of recursively structured data has a Location Independent Structure (LIS); and arranging the piece of recursively structured data in an LIS in a one-dimensional memory space in the following way: LIS:=e ⁰ ∘e ¹ ∘ . . . ∘e ^(p−1)∘LIS⁰∘LIS¹∘ . . . ∘LIS^(p−1). wherein the variable p is a positive integer, the notation e^(i) represents an element of the piece of recursively structured data, the notation LIS^(i) represents a sub-LIS of the recursively structured data and corresponds to the element e^(i), the variable i is an index of the elements and is between 0 and p−1, the operator ‘∘’ indicates “contiguous to” in the one-dimensional memory space, each of the sub-LISs is of an LIS size, a depth associated to each sub-LIS is a number of recursions from the top LIS, the depth of each of the LIS^(i) equals the depth of the LIS plus one, and the depth of the top LIS is zero, wherein when the elements in all depths are of the element size and the LIS sizes of the sub-LISs within the same depth are the same, the piece of recursively structured data is a complete LIS.
 14. The non-transitory tangible machine-readable medium of claim 13, wherein when the piece of recursively structured data is the complete LIS, the piece of recursively structured data whose maximum depth is n is denoted as an array in the following way: LIS T X[D ₀ ,D ₁ ,D ₂ , . . . ,D _(n)], wherein X is the name of the piece of recursively structured data, the variable n is a nonnegative integer, the array is of n+1 dimensions, each of the dimensions corresponds to a dimension size, the notation T represents a data type of the elements, the variable D_(j) represents the dimension size of the j-th dimension, the j-th dimension corresponds to the j-th depth of the piece of recursively structured data, and the variable j is an index of the dimension between 0 and n, wherein each of the elements is denoted as X[I₀, . . . , I_(m)], the variable m is an integer between 0 and n, the variable I_(m) represents an index corresponding to the m-th dimension, I_(m) is between 0 and D_(m)−1, the notation X[I₀] is the I₀-th element of the LIS, the notation X[I₀, . . . , I_(m−1), I_(m)] is the I_(m)-th element of LIS_(m) ^(I) ^(m−1) , and the notation LIS_(m) ^(I) ^(m−1) represents the I_(m−1)-th sub-LIS of the depth m.
 15. The non-transitory tangible machine-readable medium of claim 14, wherein the element X[I₀, . . . , I_(m−1), I_(m)] is located by the following path: LIS→X[I ₀]→LIS₁ ^(I) ⁰ →X[I ₀ ,I ₁]→LIS₂ ^(I) ¹ → . . . →X[I ₀ , . . . ,I _(m−1)]→LIS₁ ^(I) ^(m−1) →X[I ₀ , . . . ,I _(m)], wherein the notation LIS_(m) ^(I) ^(j−1) represents the sub-LIS corresponding to the element X[I₀, . . . , I_(j−1)] and 0<j≦m.
 16. The non-transitory tangible machine-readable medium of claim 14, wherein the data processing method further comprises the following steps of: receiving an instruction comprising an index combination, wherein the index combination is represented as (I₀, . . . , I_(m)); and retrieving the element corresponding to the index combination and the sub-LIS corresponding to the index combination from the one-dimensional memory space according to the following equations: $\mspace{70mu} \left\{ {\begin{matrix} {S_{m} = {D_{m} \times \left( {t + S_{m + 1}} \right)}} & {{{for}\mspace{14mu} 0} \leq m \leq n} \\ {S_{m} = 0} & {{{for}\mspace{14mu} m} > n} \end{matrix},\left\{ {\begin{matrix} {{X\left( I_{0} \right\rbrack} = {{{LIS}(X)} + {I_{0} \times t}}} & \; \\ {{X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} = {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m - 1}} \right\rbrack} \right)} + {I_{m} \times t}}} & {{{for}\mspace{14mu} 0} < m \leq n} \end{matrix},{{and}\left\{ {\begin{matrix} {{{LIS}\left( {X\left\lbrack I_{0} \right\rbrack} \right)} = {{{LIS}(X)} + {D_{0} \times t} + {I_{0} \times S_{1}}}} & \; \\ \begin{matrix} {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m}} \right\rbrack} \right)} = {{{LIS}\left( {X\left\lbrack {I_{0},\ldots \mspace{11mu},I_{m - 1}} \right\rbrack} \right)} +}} \\ {{D_{m} \times t} + {I_{m} \times S_{m + 1}}} \end{matrix} & {{{for}\mspace{14mu} 0} < m < n} \end{matrix},} \right.}} \right.} \right.$ wherein the notation S₁ represents the LIS size of the first dimension, the notation S_(m) represents the LIS size of the m^(th) dimension, the notation S_(m+1) represents the LIS size of the m+1^(th) dimension, the variable t represents the element size, the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation LIS(X) represents an offset of the LIS X, the notation LIS(X[I₀]) represents an offset of the sub-LIS corresponding to the element X[I₀], the notation LIS(X[I₀, . . . , I_(m−1), I_(m)]) represents an offset of the sub-LIS corresponding to the element X[I₀, . . . , I_(m−1), I_(m)], and the notation LIS(X[I₀, . . . , I_(m)]) represents an offset of the sub-LIS for the index combination (I₀, . . . , I_(m)) and corresponds to the element X[I₀, . . . , I_(m)].
 17. The non-transitory tangible machine-readable medium of claim 14, wherein the data processing method further comprises the following step of: receiving an instruction comprising an index combination, wherein the index combination is represented as (I₀, . . . , I_(m)), the variable m is a non-negative integer between zero and n, the notation I_(k) represents an index corresponding to the k^(th) dimension, and the variable k is an index between 0 and m; and calculating a value for the element corresponding to the index combination by an aggregation function according to the following equation:   X[I₀, …  , I_(m)] = f(LIS(X[I₀, …  , I_(m)])) = f(X[I₀, …  , I_(m), 0], X[I₀, …  , I_(m), 1], …  , X[I₀, …  , I_(m), D_(m + 1) − 1])  for  0 ≤ m < n, wherein the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation f( ) represents the aggregation function, the notation LIS(X[I₀, . . . , I_(m)]) represents the sub-LIS for the index combination (I₀, . . . , I_(m)), the notation X[I₀, . . . , I_(m), 0] represents the element for an index combination (I₀, . . . , I_(m), 0), the notation X[I₀, . . . , I_(m), 1] represents the element for an index combination (I₀, . . . , I_(m), 1), the notation X[I₀, . . . , I_(m), D_(m+1)−1] element for an index combination (I₀, . . . , I_(m), D_(m+1)−1), and the notation D_(m+1) represents the dimension size of the m+1^(th) dimension.
 18. The non-transitory tangible machine-readable medium of claim 14, wherein the data processing method further comprises the following step of: receiving an instruction comprising an index combination, wherein the index combination is represented as (I₀, . . . , I_(m)), the variable m is a non-negative integer between zero and n, the notation I_(k) represents an index corresponding to the k^(th) dimension, and the variable k is an index between 0 and m; and calculates a value for the element corresponding to the index combination by a distribution function according to the following equation: (X[I ₀ , . . . ,I _(m),0],X[I ₀ , . . . ,I _(m),1], . . . ,X[I ₀ , . . . ,I _(m) ,D _(m+1)−1])=g(X[I ₀ , . . . ,I _(m)]) for 0≦m<n′ wherein the notation X[I₀, . . . , I_(m)] represents the element for the index combination (I₀, . . . , I_(m)), the notation g( ) represents the distribution function, the notation [I₀, . . . , I_(m), 0] represents the element for an index combination (I₀, . . . , I_(m), 0), the notation [I₀, . . . , I_(m), 1] represents the element for an index combination (I₀, . . . , I_(m), 1), the notation X[(I₀, . . . , I_(m), D_(m+1)−1)] represents the element for an index combination (I₀, . . . , I_(m), D_(m+1)−1), and the notation D_(m+1) represents the dimension size of the m+1^(th) dimension. 